/**
 *
 */
import Util;
import OpenApi;

import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('metastore', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AccessRequest {
  catalogId?: string(name='CatalogId'),
  principal?: Principal(name='Principal'),
  privilegeResources?: [
PrivilegeResource
](name='PrivilegeResources'),
}

model AccessTypeDef {
  impliedGrants?: [ string ](name='ImpliedGrants'),
  itemId?: long(name='ItemId'),
  label?: string(name='Label'),
  name?: string(name='Name'),
  rbKeyLabel?: string(name='RbKeyLabel'),
}

model Catalog {
  catalogId?: string(name='CatalogId'),
  catalogName?: string(name='CatalogName'),
  catalogType?: string(name='CatalogType'),
  createTime?: long(name='CreateTime'),
  createdBy?: string(name='CreatedBy'),
  defaultCatalog?: boolean(name='DefaultCatalog'),
  description?: string(name='Description'),
  jdbcEnabled?: boolean(name='JdbcEnabled'),
  locationUri?: string(name='LocationUri'),
  owner?: string(name='Owner'),
  status?: string(name='Status'),
  storageType?: string(name='StorageType'),
  thriftEnabled?: boolean(name='ThriftEnabled'),
  updateTime?: long(name='UpdateTime'),
}

model CatalogInput {
  authorizationType?: string(name='AuthorizationType'),
  catalogId?: string(name='CatalogId', description='This parameter is required.'),
  catalogName?: string(name='CatalogName', description='This parameter is required.'),
  catalogType?: string(name='CatalogType'),
  catalogVpcConnectionInfo?: CatalogVpcConnectionInfo(name='CatalogVpcConnectionInfo'),
  description?: string(name='Description'),
  jdbcEnabled?: boolean(name='JdbcEnabled'),
  locationUri?: string(name='LocationUri'),
  owner?: string(name='Owner'),
  storageType?: string(name='StorageType'),
  thriftEnabled?: boolean(name='ThriftEnabled'),
}

model CatalogOrderInfo {
  orderId?: long(name='OrderId'),
}

model CatalogResource {
  catalogId?: string(name='CatalogId'),
}

model CatalogSettings {
  config?: map[string]string(name='Config'),
}

model CatalogVpcConnectionInfo {
  bizId?: string(name='BizId'),
  endpointId?: string(name='EndpointId'),
}

model ColumnResource {
  columnNames?: [ string ](name='ColumnNames'),
  databaseName?: string(name='DatabaseName', example='default'),
  tableName?: string(name='TableName', example='test'),
}

model ColumnStatistics {
  columnStatisticsDesc?: ColumnStatisticsDesc(name='ColumnStatisticsDesc'),
  columnStatisticsObjList?: [
    ColumnStatisticsObj
  ](name='ColumnStatisticsObjList'),
  engine?: string(name='Engine'),
  isStatsCompliant?: boolean(name='IsStatsCompliant'),
}

model ColumnStatisticsDesc {
  lastAnalyzedTime?: long(name='LastAnalyzedTime'),
  partitionName?: string(name='PartitionName'),
}

model ColumnStatisticsObj {
  columnName?: string(name='ColumnName'),
  columnStatisticsData?: {
    statisticsData?: string(name='StatisticsData'),
    statisticsType?: string(name='StatisticsType'),
  }(name='ColumnStatisticsData'),
  columnType?: string(name='ColumnType'),
}

model Database {
  createTime?: int32(name='CreateTime'),
  createdBy?: string(name='CreatedBy'),
  description?: string(name='Description'),
  lastModifyTime?: long(name='LastModifyTime'),
  locationUri?: string(name='LocationUri', example='oss://examplebuket/exampledb'),
  name?: string(name='Name'),
  ownerName?: string(name='OwnerName'),
  ownerType?: string(name='OwnerType'),
  parameters?: map[string]string(name='Parameters'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
  updateTime?: int32(name='UpdateTime'),
}

model DatabaseInput {
  createTime?: int32(name='CreateTime'),
  description?: string(name='Description'),
  locationUri?: string(name='LocationUri', example='oss://examplebuket/exampledb'),
  name?: string(name='Name'),
  ownerName?: string(name='OwnerName'),
  ownerType?: string(name='OwnerType'),
  parameters?: map[string]string(name='Parameters'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
}

model DatabaseResource {
  databaseName?: string(name='DatabaseName', example='default'),
  databaseWildcard?: string(name='DatabaseWildcard'),
}

model ErrorDetail {
  code?: string(name='Code'),
  message?: string(name='Message'),
}

model FieldSchema {
  comment?: string(name='Comment'),
  name?: string(name='Name'),
  parameters?: map[string]string(name='Parameters'),
  type?: string(name='Type'),
}

model Function {
  catalogId?: string(name='CatalogId'),
  className?: string(name='ClassName'),
  createTime?: int32(name='CreateTime'),
  createdBy?: string(name='CreatedBy', example='CreatedBy'),
  databaseName?: string(name='DatabaseName'),
  functionName?: string(name='FunctionName'),
  functionType?: string(name='FunctionType'),
  ownerName?: string(name='OwnerName'),
  ownerType?: string(name='OwnerType'),
  resourceUri?: [
    ResourceUri
  ](name='ResourceUri'),
  updateTime?: int32(name='UpdateTime'),
}

model FunctionInput {
  className?: string(name='ClassName'),
  createTime?: int32(name='CreateTime'),
  functionName?: string(name='FunctionName'),
  functionType?: string(name='FunctionType'),
  ownerName?: string(name='OwnerName'),
  ownerType?: string(name='OwnerType'),
  resourceUri?: [
    ResourceUri
  ](name='ResourceUri'),
}

model FunctionResource {
  databaseName?: string(name='DatabaseName', example='default'),
  functionName?: string(name='FunctionName', example='default'),
}

model GrantRevokeEntry {
  accesses?: [ string ](name='Accesses'),
  delegateAccesses?: [ string ](name='DelegateAccesses'),
  id?: string(name='Id'),
  metaResource?: MetaResource(name='MetaResource'),
  principal?: Principal(name='Principal'),
}

model GrantRevokeFailureEntry {
  errorDetail?: ErrorDetail(name='ErrorDetail'),
  grantRevokeEntry?: GrantRevokeEntry(name='GrantRevokeEntry'),
}

model HighLight {
  key?: string(name='Key', example='name'),
  value?: string(name='Value', example='<em>tab</em>2'),
}

model LockObj {
  catalogId?: string(name='CatalogId'),
  databaseName?: string(name='DatabaseName'),
  partitionName?: string(name='PartitionName'),
  tableName?: string(name='TableName'),
}

model LockStatus {
  lockId?: long(name='LockId'),
  lockState?: string(name='LockState'),
}

model MetaResource {
  catalogResource?: CatalogResource(name='CatalogResource'),
  columnResource?: ColumnResource(name='ColumnResource'),
  databaseResource?: DatabaseResource(name='DatabaseResource'),
  functionResource?: FunctionResource(name='FunctionResource'),
  resourceType?: string(name='ResourceType', example='TABLE'),
  tableResource?: TableResource(name='TableResource'),
}

model Order {
  col?: string(name='Col'),
  order?: int32(name='Order'),
}

model Partition {
  createTime?: int32(name='CreateTime'),
  databaseName?: string(name='DatabaseName'),
  lastAccessTime?: int32(name='LastAccessTime'),
  lastAnalyzedTime?: int32(name='LastAnalyzedTime'),
  lastModifyTime?: long(name='LastModifyTime'),
  parameters?: map[string]string(name='Parameters'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
  sd?: StorageDescriptor(name='Sd'),
  tableName?: string(name='TableName'),
  values?: [ string ](name='Values'),
}

model PartitionError {
  errorDetail?: ErrorDetail(name='ErrorDetail'),
  partitionValues?: [ string ](name='PartitionValues'),
}

model PartitionInput {
  createTime?: int32(name='CreateTime'),
  databaseName?: string(name='DatabaseName'),
  lastAccessTime?: int32(name='LastAccessTime'),
  lastAnalyzedTime?: int32(name='LastAnalyzedTime'),
  parameters?: map[string]string(name='Parameters'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
  sd?: StorageDescriptor(name='Sd'),
  tableName?: string(name='TableName'),
  values?: [ string ](name='Values'),
}

model PartitionSpec {
  sharedSDPartitions?: [
    Partition
  ](name='SharedSDPartitions'),
  sharedStorageDescriptor?: {
    cols?: [
      FieldSchema
    ](name='Cols'),
    location?: string(name='Location', example='相对路径'),
  }(name='SharedStorageDescriptor'),
}

model Policy {
  allowExceptions?: [
    PolicyItem
  ](name='AllowExceptions'),
  conditions?: [
    PolicyItemCondition
  ](name='Conditions'),
  denyExceptions?: [
    PolicyItem
  ](name='DenyExceptions'),
  denyPolicyItems?: [
    PolicyItem
  ](name='DenyPolicyItems'),
  description?: string(name='Description'),
  id?: string(name='Id'),
  isAuditEnabled?: boolean(name='IsAuditEnabled'),
  isDenyAllElse?: boolean(name='IsDenyAllElse'),
  isEnabled?: boolean(name='IsEnabled'),
  name?: string(name='Name'),
  options?: map[string]string(name='Options'),
  policyItems?: [
    PolicyItem
  ](name='PolicyItems'),
  policyLabels?: [ string ](name='PolicyLabels'),
  policyPriority?: int32(name='PolicyPriority'),
  policyType?: int32(name='PolicyType'),
  resourceSignature?: string(name='ResourceSignature'),
  resources?: {
    column?: {
      isExcludes?: boolean(name='IsExcludes'),
      isRecursive?: boolean(name='IsRecursive'),
      values?: [ string ](name='Values'),
    }(name='Column'),
    database?: {
      isExcludes?: boolean(name='IsExcludes'),
      isRecursive?: boolean(name='IsRecursive'),
      values?: [ string ](name='Values'),
    }(name='Database'),
    path?: {
      isExcludes?: boolean(name='IsExcludes'),
      isRecursive?: boolean(name='IsRecursive'),
      values?: [ string ](name='Values'),
    }(name='Path'),
    table?: {
      isExcludes?: boolean(name='IsExcludes'),
      isRecursive?: boolean(name='IsRecursive'),
      values?: [ string ](name='Values'),
    }(name='Table'),
    udf?: {
      isExcludes?: boolean(name='IsExcludes'),
      isRecursive?: boolean(name='IsRecursive'),
      values?: [ string ](name='Values'),
    }(name='Udf'),
  }(name='Resources'),
  service?: string(name='Service'),
  validitySchedules?: [ 
    {
      endTime?: string(name='EndTime'),
      startTime?: string(name='StartTime'),
      timeZone?: string(name='TimeZone'),
    }
  ](name='ValiditySchedules'),
  version?: long(name='Version'),
}

model PolicyItem {
  accesses?: [ 
    {
      isAllowed?: boolean(name='IsAllowed'),
      type?: string(name='Type'),
    }
  ](name='Accesses'),
  conditions?: [
    PolicyItemCondition
  ](name='Conditions'),
  delegateAdmin?: boolean(name='DelegateAdmin'),
  groups?: [ string ](name='Groups'),
  roles?: [ string ](name='Roles'),
  users?: [ string ](name='Users'),
}

model PolicyItemCondition {
  type?: string(name='Type'),
  values?: [ string ](name='Values'),
}

model Principal {
  principalArn?: string(name='PrincipalArn', example='acs:ram::[AliyunAccountId]:user/username_abc'),
  principalName?: string(name='PrincipalName'),
  principalType?: string(name='PrincipalType'),
}

model PrincipalPrivilegeSet {
  groupPrivileges?: map[string][
    PrivilegeGrantInfo
  ](name='GroupPrivileges'),
  rolePrivileges?: map[string][
    PrivilegeGrantInfo
  ](name='RolePrivileges'),
  userPrivileges?: map[string][
    PrivilegeGrantInfo
  ](name='UserPrivileges'),
}

model PrincipalResourcePermissions {
  accesses?: [ string ](name='Accesses'),
  delegateAccesses?: [ string ](name='DelegateAccesses'),
  metaResource?: MetaResource(name='MetaResource', description='This parameter is required.'),
  principal?: Principal(name='Principal', description='This parameter is required.'),
}

model PrivilegeGrantInfo {
  createTime?: int32(name='CreateTime'),
  grantOption?: boolean(name='GrantOption'),
  grantor?: string(name='Grantor'),
  grantorType?: string(name='GrantorType'),
  privilege?: string(name='Privilege'),
}

model PrivilegeResource {
  access?: string(name='Access'),
  metaResource?: MetaResource(name='MetaResource'),
}

model ResourceDef {
  accessTypeRestrictions?: [ string ](name='AccessTypeRestrictions'),
  description?: string(name='Description'),
  excludesSupported?: boolean(name='ExcludesSupported'),
  isValidLeaf?: boolean(name='IsValidLeaf'),
  itemId?: long(name='ItemId'),
  label?: string(name='Label'),
  level?: int32(name='Level'),
  lookupSupported?: boolean(name='LookupSupported'),
  mandatory?: boolean(name='Mandatory'),
  matcher?: string(name='Matcher'),
  matcherOptions?: map[string]string(name='MatcherOptions'),
  name?: string(name='Name'),
  parent?: string(name='Parent'),
  rbKeyDescription?: string(name='RbKeyDescription'),
  rbKeyLabel?: string(name='RbKeyLabel'),
  rbKeyValidationMessage?: string(name='RbKeyValidationMessage'),
  recursiveSupported?: boolean(name='RecursiveSupported'),
  type?: string(name='Type'),
  uiHint?: string(name='UiHint'),
  validationMessage?: string(name='ValidationMessage'),
  validationRegEx?: string(name='ValidationRegEx'),
}

model ResourceUri {
  resourceType?: string(name='ResourceType'),
  uri?: string(name='Uri'),
}

model Role {
  createTime?: long(name='CreateTime'),
  description?: string(name='Description'),
  displayName?: string(name='DisplayName', example='显示名称，允许中文'),
  groups?: [
Principal
](name='Groups'),
  isPredefined?: int32(name='IsPredefined'),
  name?: string(name='Name'),
  principalArn?: string(name='PrincipalArn'),
  updateTime?: long(name='UpdateTime'),
  users?: [
Principal
](name='Users'),
}

model RoleInput {
  description?: string(name='Description'),
  displayName?: string(name='DisplayName', example='显示名称，允许中文'),
  name?: string(name='Name'),
}

model SerDeInfo {
  name?: string(name='Name'),
  parameters?: map[string]string(name='Parameters'),
  serializationLib?: string(name='SerializationLib'),
}

model ServiceDef {
  accessTypes?: [
    AccessTypeDef
  ](name='AccessTypes'),
  configs?: [ 
    {
      defaultValue?: string(name='DefaultValue'),
      description?: string(name='Description'),
      itemId?: long(name='ItemId'),
      label?: string(name='Label'),
      mandatory?: boolean(name='Mandatory'),
      name?: string(name='Name'),
      rbKeyDescription?: string(name='RbKeyDescription'),
      rbKeyLabel?: string(name='RbKeyLabel'),
      rbKeyValidationMessage?: string(name='RbKeyValidationMessage'),
      subType?: string(name='SubType'),
      type?: string(name='Type'),
      uiHint?: string(name='UiHint'),
      validationMessage?: string(name='ValidationMessage'),
      validationRegEx?: string(name='ValidationRegEx'),
    }
  ](name='Configs'),
  createTime?: long(name='CreateTime'),
  dataMaskDef?: {
    accessTypes?: [
      AccessTypeDef
    ](name='AccessTypes'),
    maskTypes?: [ 
      {
        dataMaskOptions?: map[string]string(name='DataMaskOptions'),
        description?: string(name='Description'),
        itemId?: long(name='ItemId'),
        label?: string(name='Label'),
        name?: string(name='Name'),
        rbKeyDescription?: string(name='RbKeyDescription'),
        rbKeyLabel?: string(name='RbKeyLabel'),
        transformer?: string(name='Transformer'),
      }
    ](name='MaskTypes'),
    resources?: [
      ResourceDef
    ](name='Resources'),
  }(name='DataMaskDef'),
  description?: string(name='Description'),
  displayName?: string(name='DisplayName'),
  enums?: [ 
    {
      defaultIndex?: int32(name='DefaultIndex'),
      elements?: [ 
        {
          itemId?: long(name='ItemId'),
          label?: string(name='Label'),
          name?: string(name='Name'),
          rbKeyLabel?: string(name='RbKeyLabel'),
        }
      ](name='Elements'),
      itemId?: long(name='ItemId'),
      name?: string(name='Name'),
    }
  ](name='Enums'),
  id?: long(name='Id'),
  implClass?: string(name='ImplClass'),
  isEnabled?: boolean(name='IsEnabled'),
  label?: string(name='Label'),
  name?: string(name='Name'),
  options?: map[string]string(name='Options'),
  rbKeyDescription?: string(name='RbKeyDescription'),
  rbKeyLabel?: string(name='RbKeyLabel'),
  resources?: [
    ResourceDef
  ](name='Resources'),
  rowFilterDef?: {
    accessTypes?: [
      AccessTypeDef
    ](name='AccessTypes'),
    resources?: [
      ResourceDef
    ](name='Resources'),
  }(name='RowFilterDef'),
  updateTime?: long(name='UpdateTime'),
  version?: long(name='Version'),
}

model SkewedInfo {
  skewedColNames?: [ string ](name='SkewedColNames'),
  skewedColValueLocationMaps?: map[string]string(name='SkewedColValueLocationMaps'),
  skewedColValues?: [[ string ]  ](name='SkewedColValues'),
}

model SortCriterion {
  fieldName?: string(name='FieldName', example='name'),
  sort?: string(name='Sort', example='asc/desc'),
}

model StorageDescriptor {
  bucketCols?: [ string ](name='BucketCols'),
  cols?: [
    FieldSchema
  ](name='Cols'),
  compressed?: boolean(name='Compressed'),
  inputFormat?: string(name='InputFormat'),
  location?: string(name='Location'),
  numBuckets?: int32(name='NumBuckets'),
  outputFormat?: string(name='OutputFormat'),
  parameters?: map[string]string(name='Parameters'),
  serDeInfo?: SerDeInfo(name='SerDeInfo'),
  skewedInfo?: SkewedInfo(name='SkewedInfo'),
  sortCols?: [
    Order
  ](name='SortCols'),
  storedAsSubDirectories?: boolean(name='StoredAsSubDirectories'),
}

model StorageFormat {
  avro?: long(name='Avro'),
  csv?: long(name='Csv'),
  delta?: long(name='Delta'),
  hudi?: long(name='Hudi'),
  iceberg?: long(name='Iceberg'),
  json?: long(name='Json'),
  orc?: long(name='Orc'),
  parquet?: long(name='Parquet'),
  uncategorized?: long(name='Uncategorized'),
}

model Table {
  cascade?: boolean(name='Cascade'),
  createTime?: int32(name='CreateTime'),
  createdBy?: string(name='CreatedBy'),
  databaseName?: string(name='DatabaseName'),
  fileFormat?: string(name='FileFormat'),
  lastAccessTime?: int32(name='LastAccessTime'),
  lastAnalyzedTime?: int32(name='LastAnalyzedTime'),
  lastModifyTime?: long(name='LastModifyTime'),
  owner?: string(name='Owner'),
  ownerType?: string(name='OwnerType'),
  parameters?: map[string]string(name='Parameters'),
  partitionKeys?: [
FieldSchema
](name='PartitionKeys'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
  retention?: int32(name='Retention'),
  rewriteEnabled?: boolean(name='RewriteEnabled'),
  sd?: StorageDescriptor(name='Sd'),
  tableFormat?: string(name='TableFormat'),
  tableId?: string(name='TableId', example='59c6c8fefeaa46d8b599c1f790c59a19'),
  tableName?: string(name='TableName'),
  tableType?: string(name='TableType'),
  tableVersion?: TableVersion(name='TableVersion'),
  temporary?: boolean(name='Temporary'),
  updateTime?: int32(name='UpdateTime'),
  viewExpandedText?: string(name='ViewExpandedText'),
  viewOriginalText?: string(name='ViewOriginalText'),
}

model TableError {
  errorDetail?: ErrorDetail(name='ErrorDetail'),
  tableName?: string(name='TableName'),
}

model TableExtended {
  cascade?: boolean(name='Cascade'),
  createTime?: int32(name='CreateTime'),
  createdBy?: string(name='CreatedBy'),
  databaseName?: string(name='DatabaseName'),
  lastAccessTime?: int32(name='LastAccessTime'),
  lastAnalyzedTime?: int32(name='LastAnalyzedTime'),
  owner?: string(name='Owner'),
  ownerType?: string(name='OwnerType'),
  parameters?: map[string]string(name='Parameters'),
  partitionKeys?: [
FieldSchema
](name='PartitionKeys'),
  privileges?: {
    rolePrivileges?: map[string][ TableExtendedPrivilegesRolePrivilegesValue     ](name='RolePrivileges'),
    userPrivileges?: map[string][ TableExtendedPrivilegesUserPrivilegesValue     ](name='UserPrivileges'),
    groupPrivileges?: map[string][ TableExtendedPrivilegesGroupPrivilegesValue     ](name='groupPrivileges'),
  }(name='Privileges'),
  retention?: int32(name='Retention'),
  rewriteEnabled?: boolean(name='RewriteEnabled'),
  sd?: {
    bucketCols?: [ string ](name='BucketCols'),
    cols?: [
      FieldSchema
    ](name='Cols'),
    compressed?: boolean(name='Compressed'),
    inputFormat?: string(name='InputFormat'),
    location?: string(name='Location'),
    numBuckets?: int32(name='NumBuckets'),
    outputFormat?: string(name='OutputFormat'),
    parameters?: map[string]string(name='Parameters'),
    serDeInfo?: {
      name?: string(name='Name'),
      parameters?: map[string]string(name='Parameters'),
      serializationLib?: string(name='SerializationLib'),
    }(name='SerDeInfo'),
    skewedInfo?: {
      skewedColNames?: [ string ](name='SkewedColNames'),
      skewedColValueLocationMaps?: map[string]string(name='SkewedColValueLocationMaps'),
      skewedColValues?: [[ string ]      ](name='SkewedColValues'),
    }(name='SkewedInfo'),
    sortCols?: [
      Order
    ](name='SortCols'),
    storedAsSubDirectories?: boolean(name='StoredAsSubDirectories'),
  }(name='Sd'),
  tableFormat?: string(name='TableFormat'),
  tableName?: string(name='TableName'),
  tableType?: string(name='TableType'),
  temporary?: boolean(name='Temporary'),
  updateTime?: int32(name='UpdateTime'),
  viewExpandedText?: string(name='ViewExpandedText'),
  viewOriginalText?: string(name='ViewOriginalText'),
}

model TableInput {
  cascade?: boolean(name='Cascade'),
  createTime?: int32(name='CreateTime'),
  createdBy?: string(name='CreatedBy'),
  databaseName?: string(name='DatabaseName'),
  lastAccessTime?: int32(name='LastAccessTime'),
  lastAnalyzedTime?: int32(name='LastAnalyzedTime'),
  owner?: string(name='Owner'),
  ownerType?: string(name='OwnerType'),
  parameters?: map[string]string(name='Parameters'),
  partitionKeys?: [
FieldSchema
](name='PartitionKeys'),
  privileges?: PrincipalPrivilegeSet(name='Privileges'),
  retention?: int32(name='Retention'),
  rewriteEnabled?: boolean(name='RewriteEnabled'),
  sd?: StorageDescriptor(name='Sd'),
  tableName?: string(name='TableName'),
  tableType?: string(name='TableType'),
  temporary?: boolean(name='Temporary'),
  viewExpandedText?: string(name='ViewExpandedText'),
  viewOriginalText?: string(name='ViewOriginalText'),
}

model TableResource {
  databaseName?: string(name='DatabaseName'),
  tableName?: string(name='TableName'),
}

model TableVersion {
  versionId?: int32(name='VersionId'),
}

model TaskStatus {
  message?: string(name='Message'),
  status?: string(name='Status'),
}

model UpdateTablePartitionColumnStatisticsRequest {
  catalogId?: string(name='CatalogId'),
  columnStatisticsList?: [
    ColumnStatistics
  ](name='ColumnStatisticsList'),
  databaseName?: string(name='DatabaseName'),
  engine?: string(name='Engine'),
  isStatsCompliant?: boolean(name='IsStatsCompliant'),
  tableName?: string(name='TableName'),
  validWriteIdList?: string(name='ValidWriteIdList'),
  writeId?: string(name='WriteId'),
}

model UserRole {
  grantTime?: long(name='GrantTime'),
  role?: Role(name='Role'),
  user?: Principal(name='User'),
}

model TableExtendedPrivilegesRolePrivilegesValue = {
  createTime?: int32(name='CreateTime'),
  grantOption?: boolean(name='GrantOption'),
  grantor?: string(name='Grantor'),
  grantorType?: string(name='GrantorType'),
  privilege?: string(name='Privilege'),
}

model TableExtendedPrivilegesUserPrivilegesValue = {
  createTime?: int32(name='CreateTime'),
  grantOption?: boolean(name='GrantOption'),
  grantor?: string(name='Grantor'),
  grantorType?: string(name='GrantorType'),
  privilege?: string(name='Privilege'),
}

model TableExtendedPrivilegesGroupPrivilegesValue = {
  createTime?: int32(name='CreateTime'),
  grantOption?: boolean(name='GrantOption'),
  grantor?: string(name='Grantor'),
  grantorType?: string(name='GrantorType'),
  privilege?: string(name='Privilege'),
}

